package org.hy.framework.spring.hibernate3.dao;

import org.hy.framework.spring.hibernate3.entity.User;
import java.io.Serializable;
import java.util.List;
import java.util.Map;

import javax.inject.Inject;


import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hy.framework.hibernate.dao.MyPlainBaseDao;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

//import com.hy.enterprise.framework.jpa.core.dao.impl.HibernateAbstractDao;
//import com.hy.enterprise.framework.jpa.core.dao.impl.HibernatePlainAbstractDao;
import com.hy.enterprise.framework.persistence.PersistentException;

import com.hy.enterprise.framework.jpa.core.entity.util.Page;

             
@Repository("userDao")
public class UserDao extends MyPlainBaseDao<User> implements IUserDao<User> {

	@Inject
	@Override
	public void setSessionFactory(SessionFactory sessionFactory) {
		//  
		super.setSessionFactory(sessionFactory);
	}

	@Override
	public SessionFactory getSessionFactory() {
		//  
		return super.getSessionFactory();
	}

	@Override
	public Session getHibernateSession() {
		//  
		return super.getHibernateSession();
	}

	@Override
	public Integer batchExecute(boolean isNamedQuery, String query,
			Map<String, ?> values) {
		//  
		return super.batchExecute(isNamedQuery, query, values);
	}

	@Override
	public Integer batchExecute(boolean isNamedQuery, String query,
			Object... values) {
		//  
		return super.batchExecute(isNamedQuery, query, values);
	}

	

	@Override
	public boolean contains(User persistentEntity)
			throws PersistentException {
		//  
		return super.contains(persistentEntity);
	}
	
	@Override
	public boolean containsById(Integer identifier) throws PersistentException {
		// 
		return super.containsById(identifier);
	}
	
	@Override
	public boolean containsByIdentifier(String identifier) throws PersistentException {
		// 		
		return super.containsByIdentifier(identifier);
	}

	

	@Override
	public Integer count() {
		//  
		return super.count();
	}

	@Override
	public Integer count(String query, boolean isNamedQuery) {
		//  
		return super.count(query, isNamedQuery);
	}

	@Override
	public Integer countByNamedQuery(String queryName, Map<String, ?> parameters) {
		//  
		return super.countByNamedQuery(queryName, parameters);
	}

	@Override
	public Integer countByNamedQuery(String queryName, Object... parameters) {
		//  
		return super.countByNamedQuery(queryName, parameters);
	}

	@Override
	public Integer countByQuery(String query, Map<String, ?> parameters) {
		//  
		return super.countByQuery(query, parameters);
	}

	@Override
	public Integer countByQuery(String query, Object... parameters) {
		//  
		return super.countByQuery(query, parameters);
	}

	@Override
	public List<User> find() throws PersistentException {
		//  
		return super.find();
	}

	@Override
	public List<User> find(int first, int max)
			throws PersistentException {
		//  
		return super.find(first, max);
	}

	@Override
	public List<User> find(int first, int max,
			String queryString, Object... values) throws PersistentException {
		//  
		return super.find(first, max, queryString, values);
	}

	@Override
	public List<User> find(String queryString)
			throws PersistentException {
		//  
		return super.find(queryString);
	}

	@Override
	public List<User> find(String queryString, int first,
			int max) throws PersistentException {
		//  
		return super.find(queryString, first, max);
	}

	@Override
	public List<User> find(String queryString,
			Map<String, ?> parameters) throws PersistentException {
		//  
		return super.find(queryString, parameters);
	}

	@Override
	public List<User> find(String queryString,
			Map<String, ?> parameters, int first, int max)
			throws PersistentException {
		//  
		return super.find(queryString, parameters, first, max);
	}

	@Override
	public List<User> find(String queryString,
			Object... values) throws PersistentException {
		//  
		return super.find(queryString, values);
	}

	@Override
	public List<User> findByExample(Object exampleInstance) {
		//  
		return super.findByExample(exampleInstance);
	}

	@Override
	public List<User> findByExample(User exampleInstance,
			String[] excludeProperty) {
		//  
		return super.findByExample(exampleInstance, excludeProperty);
	}
	
	@Override
	public User findById(Integer id) throws PersistentException {
		//  
		return super.findById(id);
	}

	@Override
	public List<User> findById(Integer... ids) throws PersistentException {
		//  
		return super.findById(ids);
	}

	@Override
	public User findByIdentifier(String identifier)
			throws PersistentException {
		//  
		return super.findByIdentifier(identifier);
	}

	@Override
	public List<User> findByIdentifier(
			String... identifiers) throws PersistentException {
		//  
		return super.findByIdentifier(identifiers);
	}

	

	@Override
	public List<User> findByNamedParams(
			String queryString, Map<String, ?> parameters)
			throws PersistentException {
		//  
		return super.findByNamedParams(queryString, parameters);
	}

	@Override
	public List<User> findByNamedParams(
			String queryString, Map<String, ?> parameters, int first, int max)
			throws PersistentException {
		//  
		return super.findByNamedParams(queryString, parameters, first, max);
	}

	@Override
	public List<User> findByNamedQuery(int first,
			int max, String queryName, Object... values)
			throws PersistentException {
		//  
		return super.findByNamedQuery(first, max, queryName, values);
	}

	@Override
	public List<User> findByNamedQuery(String queryName)
			throws PersistentException {
		//  
		return super.findByNamedQuery(queryName);
	}

	@Override
	public List<User> findByNamedQuery(String queryName,
			int first, int max) throws PersistentException {
		//  
		return super.findByNamedQuery(queryName, first, max);
	}

	@Override
	public List<User> findByNamedQuery(String queryName,
			Object... values) throws PersistentException {
		//  
		return super.findByNamedQuery(queryName, values);
	}

	@Override
	public List<User> findByNamedQueryAndNamedParams(
			String queryName, Map<String, ?> parameters)
			throws PersistentException {
		//  
		return super.findByNamedQueryAndNamedParams(queryName, parameters);
	}

	@Override
	public List<User> findByNamedQueryAndNamedParams(
			String queryName, Map<String, ?> parameters, int first, int max)
			throws PersistentException {
		//  
		return super.findByNamedQueryAndNamedParams(queryName, parameters, first, max);
	}
	
	@Override
	public Page<User> findPage(String hql) throws PersistentException {
		// 
		return super.findPage(hql);
	}

	@Override
	public Page<User> findPage(String hql, Map<String, ?> parameters) {
		// 
		return super.findPage(hql, parameters);
	}

	@Override
	public Page<User> findPage(String hql, Object... parameters) {
		// 
		return super.findPage(hql, parameters);
	}

	@Override
	public Page<User> findPage(String hql, int offset, int max,
			Object... parameters) {
		// 
		return super.findPage(hql, offset, max, parameters);
	}
	
	@Override
	public Page<User> findPageByPageNo(String hql, int pageNo) {
		// 
		return super.findPageByPageNo(hql, pageNo);
	}
	

	@Override
	public Page<User> findPageByPageNo(String hql, int pageNo,
			Object... parameters) {
		// 
		return super.findPageByPageNo(hql, pageNo, parameters);
	}

	@Override
	public Page<User> findPageByPageNo(String hql, int pageNo, int pageSize,
			Object... parameters) {
		// 
		return super.findPageByPageNo(hql, pageNo, pageSize, parameters);
	}

	@Override
	public User findUniqueResult(String queryString)
			throws PersistentException {
		//  
		return super.findUniqueResult(queryString);
	}

	@Override
	public User findUniqueResult(String queryString,
			Map<String, ?> parameters) throws PersistentException {
		//  
		return super.findUniqueResult(queryString, parameters);
	}

	@Override
	public User findUniqueResult(String queryString,
			Object... values) throws PersistentException {
		//  
		return super.findUniqueResult(queryString, values);
	}

	@Override
	public User findUniqueResultByNamedParams(
			String queryName, Map<String, ?> parameters)
			throws PersistentException {
		//  
		return super.findUniqueResultByNamedParams(queryName, parameters);
	}

	@Override
	public User findUniqueResultByNamedQuery(
			String queryName) throws PersistentException {
		//  
		return super.findUniqueResultByNamedQuery(queryName);
	}

	@Override
	public User findUniqueResultByNamedQuery(
			String queryName, Object... values) throws PersistentException {
		//  
		return super.findUniqueResultByNamedQuery(queryName, values);
	}

	@Override
	public User findUniqueResultByNamedQueryAndNamedParams(
			String queryName, Map<String, ?> parameters)
			throws PersistentException {
		//  
		return super.findUniqueResultByNamedQueryAndNamedParams(queryName, parameters);
	}

	/*@Override
	public void flush() throws PersistentException {
		//  
		super.flush();
	}*/

	/*@Override
	public void flushAndClear() {
		//  
		super.flushAndClear();
	}*/

	@Override
	public Class<User> getPersistentEneityClass() {
		//  
		return super.getPersistentEneityClass();
	}

	@Override
	public User getReference(String identifier) throws PersistentException {
		//  
		return super.getReference(identifier);
	}

	@Override
	public boolean isPropertyUnique(String propertyName, Object newValue,
			Object oldValue) {
		//  
		return super.isPropertyUnique(propertyName, newValue, oldValue);
	}

	@Override
	public User merge(User persistentEntity) throws PersistentException {
		//  
		return super.merge(persistentEntity);
	}

	@Override
	public String[] merge(User... persistentEntities)
			throws PersistentException {
		//  
		return super.merge(persistentEntities);
	}

	@Override
	public boolean persist(User persistentEntity) throws PersistentException {
		//  
		return super.persist(persistentEntity);
	}

	@Override
	public String[] persist(User... persistentEntities)
			throws PersistentException {
		//  
		return super.persist(persistentEntities);
	}

	

	@Override
	public void refresh(User persistentEntity) throws PersistentException {
		//  
		super.refresh(persistentEntity);
	}

	@Override
	public void cascadeRemove(User persistentEntity)
			throws PersistentException {
		//  
		super.cascadeRemove(persistentEntity);
	}

	@Override
	public boolean remove(User persistentEntity) throws PersistentException {
		//  
		return super.remove(persistentEntity);
	}

	@Override
	public String[] remove(User... persistentEntities)
			throws PersistentException {
		//  
		return super.remove(persistentEntities);
	}

	@Override
	public boolean remove(String identifier) throws PersistentException {
		//  
		return super.remove(identifier);
	}

	@Override
	public boolean removeById(Integer id) throws PersistentException {
		//  
		return super.removeById(id);
	}

	@Override
	public Integer remove(String... identifiers) throws PersistentException {
		//  
		return super.remove(identifiers);
	}

	@Override
	protected User createEmptyEntity() {
		//  
		return super.createEmptyEntity();
	}

	@Override
	protected Query populateParameters(Query query, Map<String, ?> parameters) {
		//  
		return super.populateParameters(query, parameters);
	}

	@Override
	protected Query populateParameters(Query query, Object... parameters) {
		//  
		return super.populateParameters(query, parameters);
	}

	@Override
	public Boolean isExists(User persistentEntity, String propertyName,
			Object propertyValue) {
		//  
		return super.isExists(persistentEntity, propertyName, propertyValue);
	}

	

}
